# 作者: 赵若云
# 2025年02月24日09时56分12秒
# 3478783573@qq.com

List1 = [1, 3, 2, 4, 5, 3, 2]

print(sorted(List1))  # sorted函数返回一个新的有序列表，原列表不变
print(List1)
# List1.sort()
# print(List1)

print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))  # 排序是排字典的键，这里是 1 2 3 4 5
print('-' * 50)

# 字符串排序
str_List = "This is a test string from Andrew".split()
print(str_List)
print(sorted(str_List))  # T会在a前面，因为它是小写字母，下面函数str_lower可以实现忽略大小写的排序


def str_lower(str1: str):
    """
    比较规则函数
    :param str1:
    :return:
    """
    return str1.lower()  # lower()方法实现忽略大小写的排序，，将所有字母转换为小写字母


# str_lower这里也是作为回调函数传入sorted函数，即sorted内部进行调用str_lower函数
# 尽在排序的时候调用str_lower函数，将所有字母转换为小写字母，然后进行排序，但排序的内容还是按照原来的
print(sorted(str_List, key=str_lower))
print(sorted(str_List, key=str.lower))  # 等价于上面
print('-' * 50)

# shift+alt竖选
# 列表排序
student_tuples = [
    ('john', 'A', 15),
    ('jane', 'B', 12),
    ('dave', 'B', 10),
]

# 匿名函数lambda:函数在当前位置只是用一次，不需要再其他地方再次调用，就会使用匿名函数
# 提升了代码的阅读效率，x[2]代表第3项
print(sorted(student_tuples, key=lambda x: x[2]))  # ：之后才是返回值


# 排一个对象
class Student:
    def __init__(self, name, grade, age):
        self.name = name
        self.grade = grade
        self.age = age

    def __repr__(self):
        """
        没重写的时候，默认返回对象的内存地址
        类似str，但可以返回非字符串类型，一般是元组类型
        当str和repr同时存在，在排序时repr的优先级更高，单独输出str的优先级更高，但不会同时去写
        :return:
        """
        return repr((self.name, self.grade, self.age))


student_objects = [
    Student('john', 'A', 15),
    Student('jane', 'B', 12),
    Student('dave', 'B', 10),
]

# 重写了__repr__方法，所以输出的结果是元组类型
# 如果没有重写__repr__方法，则输出的结果是内存地址
print(sorted(student_objects, key=lambda student: student.age))
print('-' * 50)

# 官方排序函数
from operator import itemgetter, attrgetter

# print(sorted(student_tuples, key=lambda x: x[2]))与下面相同
print(sorted(student_tuples, key=itemgetter(2)))  # 用于元组或列表
# print(sorted(student_objects, key=lambda student: student.age))与下面相同
print(sorted(student_objects, key=attrgetter('age')))  # 用于对象
print('-' * 50)

# 多层排序
# 用于元组或列表
print(sorted(student_tuples, key=itemgetter(1, 2)))
print(sorted(student_tuples, key=lambda x: x[1:]))  # 切片
# 用于对象
print(sorted(student_objects, key=attrgetter('grade', 'age'), reverse=True))
print(sorted(student_objects, key=lambda student: (student.grade, student.age), reverse=True))
print('-' * 50)

# 感受排序的稳定性，Python用的是归并排序，是稳定的；C++用的是快速排序，是不稳定的
data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
print(sorted(data, key=lambda x: x[0]))  # 稳定
print('-' * 50)

# 字典排序{}
mydict = {'Li': ['M', 7],
          'Zhang': ['E', 2],
          'Wang': ['P', 3],
          'Du': ['C', 2],
          'Ma': ['C', 9],
          'Zhe': ['H', 7]}

for v in mydict.items():
    print(v)
print(sorted(mydict.items(), key=lambda v: v[1][1]))  # 别忘了字典后面加items()，不加的话是按照key排序

# 列表嵌套字典排序
game_result = [
    {"name": "Bob", "wins": 10, "losses": 3, "rating": 75.00},
    {"name": "David", "wins": 3, "losses": 5, "rating": 57.00},
    {"name": "Carol", "wins": 4, "losses": 5, "rating": 57.00},
    {"name": "Patty", "wins": 9, "losses": 3, "rating": 71.48}
]
print(sorted(game_result, key=itemgetter('rating', 'name')))  # 升序排列
print('-' * 50)
# 定义要排序的元组列表
tuples = [(3, 5), (1, 2), (2, 4), (3, 1), (1, 3)]

# ctrl+r 是搜索
# 使用sorted函数进行排序，结合lambda表达式定义排序规则
sorted_tuples = sorted(tuples, key=lambda x: (x[0], -x[1]))  # -x[1]是降序排列
print(sorted_tuples)
